﻿#include "CasoDePrueba.h"
#include "PruebasMock.h"

CasoDePrueba::CasoDePrueba(Puntero<ISistema> (*inicializar)(nat VELOCIDAD_OMNIBUS, nat VELOCIDAD_AVION, nat COSTO_OMNIBUS, nat COSTO_AVION, nat CAPACIDAD_OMNIBUS, nat CAPACIDAD_AVION, nat MAX_CIUDADES, nat MAX_EXCURSIONES))
{
	this->inicializar = inicializar;
	m_PlantillaTransporte = "({0}->{1},{2},{3})";
}

Puntero<ISistema> CasoDePrueba::InicializarSistema(nat VELOCIDAD_OMNIBUS, nat VELOCIDAD_AVION, nat COSTO_OMNIBUS, nat COSTO_AVION, nat CAPACIDAD_OMNIBUS, nat CAPACIDAD_AVION, nat MAX_CIUDADES, nat MAX_EXCURSIONES)
{
	Puntero<ISistema> interfaz = inicializar(VELOCIDAD_OMNIBUS, VELOCIDAD_AVION, COSTO_OMNIBUS, COSTO_AVION, CAPACIDAD_OMNIBUS, CAPACIDAD_AVION, MAX_CIUDADES, MAX_EXCURSIONES);
	ignorarOK = false;
	return interfaz;
}

void CasoDePrueba::InicializarCiudad(Puntero<ISistema> interfaz)
{
	Array<pCiudad> ciudades = ObtenerCiudadesDelSistema();
	Cadena ingreso = " Se ingresa la ciudad {0}";

	foreach (ciudad, ciudades)
		Verificar(interfaz->IngresoCiudad(ciudad->ObtenerNombre()), OK, ingreso.DarFormato(ciudad->ObtenerNombre()));
}

void CasoDePrueba::InicializarAtraccion(Puntero<ISistema> interfaz)
{
	Array<pAtraccion> atracciones = ObtenerAtraccionesDelSistema();
	Cadena ingreso = " Se ingresa la atracción {0}";

	foreach (atraccion, atracciones)
		Verificar(interfaz->IngresoAtraccion(atraccion->ObtenerIdentificador(), atraccion->ObtenerNombre(), atraccion->ObtenerHorarioInicio(), atraccion->ObtenerHorarioFin(), atraccion->ObtenerCiudad()->ObtenerNombre(), atraccion->ObtenerPrecio()), OK, ingreso.DarFormato(atraccion->ObtenerNombre()));
}

void CasoDePrueba::InicializarConexion(Puntero<ISistema> interfaz)
{
	Cadena comentario = "Se da de alta la conexión {0}-{1}";

	Verificar(interfaz->AltaConexion("Rio de Janeiro", "Miami", 5500, 0, 2), OK, comentario.DarFormato("Rio de Janeiro","Miami"));
	Verificar(interfaz->AltaConexion("Miami", "Chicago", 962, 1, 4), OK, comentario.DarFormato("Miami","Chicago"));
	Verificar(interfaz->AltaConexion("Montevideo", "Punta del Este", 120, 5, 1), OK, comentario.DarFormato("Montevideo","Punta del Este"));
	Verificar(interfaz->AltaConexion("Montevideo", "Buenos Aires", 200, 2, 6), OK, comentario.DarFormato("Montevideo","Buenos Aires"));
	Verificar(interfaz->AltaConexion("Montevideo", "Rio de Janeiro", 915, 2, 4), OK, comentario.DarFormato("Montevideo","Rio de Janeiro"));
	Verificar(interfaz->AltaConexion("Buenos Aires", "San Pablo", 1000, 1, 4), OK, comentario.DarFormato("Buenos Aires","San Pablo"));
	Verificar(interfaz->AltaConexion("San Francisco", "Chicago", 890, 1, 3), OK, comentario.DarFormato("San Francisco","Chicago"));
	Verificar(interfaz->AltaConexion("San Francisco", "New York", 1100, 0, 3), OK, comentario.DarFormato("San Francisco","New York"));
	Verificar(interfaz->AltaConexion("Rio de Janeiro", "San Pablo", 410, 4, 7), OK, comentario.DarFormato("Rio de Janeiro","San Pablo"));
	Verificar(interfaz->AltaConexion("Rio de Janeiro", "Miami", 5720, 1, 5), OK, comentario.DarFormato("Rio de Janeiro","Miami"));
	Verificar(interfaz->AltaConexion("Montevideo", "Punta del Este", 140, 3, 0), OK, comentario.DarFormato("Montevideo","Punta del Este 2"));
	Verificar(interfaz->AltaConexion("Punta del Este", "Buenos Aires", 423, 3, 7), OK, comentario.DarFormato("Punta del Este","Buenos Aires"));
	Verificar(interfaz->AltaConexion("Buenos Aires", "Montevideo", 323, 3, 3), OK, comentario.DarFormato("Buenos Aires","Montevideo"));
	Verificar(interfaz->AltaConexion("Buenos Aires", "Rio de Janeiro", 1500, 1, 2), OK, comentario.DarFormato("Rio de Janeiro","Buenos Aires"));
	Verificar(interfaz->AltaConexion("Chicago", "New York", 720, 1, 4), OK, comentario.DarFormato("Chicago","New York"));
	Verificar(interfaz->AltaConexion("New York", "San Francisco", 1090, 1, 2), OK, comentario.DarFormato("New York", "San Francisco"));

	
	//EUROPA
	Verificar(interfaz->AltaConexion("Barcelona", "Valencia", 820, 1, 3), OK, comentario.DarFormato("Barcelona","Valencia"));
	Verificar(interfaz->AltaConexion("Brujas", "Bruselas", 210, 1, 2), OK, comentario.DarFormato("Brujas","Bruselas"));
	Verificar(interfaz->AltaConexion("Amsterdam", "Paris", 580, 2, 3), OK, comentario.DarFormato("Amsterdam","Paris"));
	Verificar(interfaz->AltaConexion("Amsterdam", "Londres", 2300, 1, 4), OK, comentario.DarFormato("Amsterdam","Londres"));
	Verificar(interfaz->AltaConexion("Roma", "Venecia", 645, 0, 3), OK, comentario.DarFormato("Roma","Venecia"));
	Verificar(interfaz->AltaConexion("Londres", "Shangai", 8754, 0, 1), OK, comentario.DarFormato("Londres","Shangai"));

}

void CasoDePrueba::InicializarAtraccionesAVisitar(Puntero<ISistema> interfaz)
{
	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	InicializarExcursion(interfaz);
		
	Array<pCiudad> ciudades = Array<pCiudad>(4);
	ciudades[0] = new CiudadMock("Montevideo");
	ciudades[1] = new CiudadMock("Punta del Este");
	ciudades[2] = new CiudadMock("Rio de Janeiro");
	ciudades[3] = new CiudadMock("New York");

	Array<pAtraccion> atracciones = Array<pAtraccion>(16);
	atracciones[0] = new AtraccionMock("P12", "Palacio Legislativo", 10, 17, ciudades[0], 10, NULL);
	atracciones[1] = new AtraccionMock("P34", "Palacio Salvo", 12, 20, ciudades[0], 15, NULL);
	atracciones[2] = new AtraccionMock("T11", "Torre de las Comunicaciones", 13, 18, ciudades[0], 5, NULL);
	atracciones[3] = new AtraccionMock("E56", "Estadio Centenario", 9, 19, ciudades[0], 18, NULL);
	atracciones[4] = new AtraccionMock("P78", "Parador de Playa El Emir", 0, 17, ciudades[1], 10, NULL);
	atracciones[5] = new AtraccionMock("P55","Parador de Playa los dedos", 8, 23, ciudades[1], 30, NULL);
	atracciones[6] = new AtraccionMock("H98", "Hotel Conrad", 10, 20, ciudades[1], 20, NULL);
	atracciones[7] = new AtraccionMock("P33", "Parque El Jaguel", 8, 18, ciudades[1], 18, NULL);
	atracciones[8] = new AtraccionMock("P22", "Cerro Pan de Azucar", 10, 20, ciudades[2], 10, NULL);
	atracciones[9] = new AtraccionMock("C33", "Corcovado", 8, 20, ciudades[2], 44, NULL);
	atracciones[10] = new AtraccionMock("P43", "Plaza de Copacabana", 6, 23, ciudades[2], 5, NULL);
	atracciones[11] = new AtraccionMock("S15", "Sambodromo", 10, 19, ciudades[2], 17, NULL);
	atracciones[12] = new AtraccionMock("E14", "Empire State", 10, 17, ciudades[3], 30, NULL);
	atracciones[13] = new AtraccionMock("T22", "Times Square", 10, 17, ciudades[3], 15, NULL);
	atracciones[14] = new AtraccionMock("B23", "Botanical Garden", 10, 17, ciudades[3], 17, NULL);
	atracciones[15] = new AtraccionMock("W14", "Wall Street", 10, 17, ciudades[3], 40, NULL);
	
	foreach (atraccion, atracciones)
		interfaz->IngresoAtraccion(atraccion->ObtenerIdentificador(), atraccion->ObtenerNombre(), atraccion->ObtenerHorarioInicio(), atraccion->ObtenerHorarioFin(), atraccion->ObtenerCiudad()->ObtenerNombre(), atraccion->ObtenerPrecio());

	interfaz->CalificarAtraccion(20120111, "P12", 1, "Mas feo de lo que me imaginaba");
	interfaz->CalificarAtraccion(20130510, "P12", 3, "Lindo! Aunque mucha cola para entrar");
	interfaz->CalificarAtraccion(20120301, "P34", 5, "Muy recomendable!! Me encanto");
	interfaz->CalificarAtraccion(20110825, "P34", 5, "Un sueño!");
	interfaz->CalificarAtraccion(20100108, "T11", 3, "Entretenido");
	interfaz->CalificarAtraccion(20100109, "T11", -2, "No lo recomiendo!");
	interfaz->CalificarAtraccion(20120111, "E56", 4, "Un lugar con mucha historia");
	interfaz->CalificarAtraccion(20130510, "E56", 3, "Muy lindo el parque que lo rodea");
	interfaz->CalificarAtraccion(20120301, "P78", 5, "Me encantó. La mejor playa que he ido");
	interfaz->CalificarAtraccion(20110825, "P78", 5, "Muy recomendable");
	interfaz->CalificarAtraccion(20110108, "P55", 4, "Muy vistoso");
	interfaz->CalificarAtraccion(20100108, "P55", -2, "No le encuentro el sentido");
	interfaz->CalificarAtraccion(20110108, "H98", -1, "Muy costoso");
	interfaz->CalificarAtraccion(20100108, "H98", 3, "El mejor casino que he visto");
	interfaz->CalificarAtraccion(20110108, "P33", -2, "Muy venido a menos");
	interfaz->CalificarAtraccion(20100108, "P33", 3, "Podría mejorar con mantenimiento");
	interfaz->CalificarAtraccion(20100108, "P22", 5, "La mejor vista");
	interfaz->CalificarAtraccion(20130510, "P22", 3, "Lindo! Aunque mucha cola para subir");
	interfaz->CalificarAtraccion(20130509, "C33", 1, "Me lo imaginé más lindo");
	interfaz->CalificarAtraccion(20130510, "C33", 3, "Muy linda la subida en tren");

	ignorarOK = false;


}

void CasoDePrueba::InicializarExcursion(Puntero<ISistema> interfaz)
{
	Array<Cadena> listado(4);
	listado[0] = Cadena("Montevideo");
	listado[1] = Cadena("Punta del Este");
	listado[2] = Cadena("Rio de Janeiro");
	listado[3] = Cadena("New York");

	Verificar(interfaz->IngresoExcursionItinerario(1,20141212, listado.ObtenerIterador()), OK, "Se ingresa la excursión 1: Montevideo, Punta del Este, Rio de Janeiro, New York.");
	
	Array<Cadena> listado2(4);
	listado2[0] = Cadena("Buenos Aires");
	listado2[1] = Cadena("Montevideo");
	listado2[2] = Cadena("Miami");
	listado2[3] = Cadena("New York");

	Verificar(interfaz->IngresoExcursionItinerario(2,20140910, listado2.ObtenerIterador()), OK, "Se ingresa la excursión 2: Buenos Aires, Montevideo, Miami, New York.");
}

Array<pCiudad> CasoDePrueba::ObtenerCiudadesDelSistema()
{
	Array<pCiudad> retorno = Array<pCiudad>(22);

	retorno[0] = new CiudadMock("Montevideo");
	retorno[1] = new CiudadMock("Punta del Este");
	retorno[2] = new CiudadMock("Buenos Aires");
	retorno[3] = new CiudadMock("Rio de Janeiro");
	retorno[4] = new CiudadMock("Miami");
	retorno[5] = new CiudadMock("San Francisco");
	retorno[6] = new CiudadMock("Chicago");
	retorno[7] = new CiudadMock("New York");
	retorno[8] = new CiudadMock("Paris");
	retorno[9] = new CiudadMock("Amsterdam");
	retorno[10] = new CiudadMock("Londres");
	retorno[11] = new CiudadMock("Barcelona");
	retorno[12] = new CiudadMock("Madrid");
	retorno[13] = new CiudadMock("Valencia");
	retorno[14] = new CiudadMock("Shangai");
	retorno[15] = new CiudadMock("Hong Kong");
	retorno[16] = new CiudadMock("Brujas");
	retorno[17] = new CiudadMock("Bruselas");
	retorno[18] = new CiudadMock("San Pablo");
	retorno[19] = new CiudadMock("Roma");
	retorno[20] = new CiudadMock("Venecia");
	retorno[21] = new CiudadMock("Atenas");

	return retorno;
}

Array<pAtraccion> CasoDePrueba::ObtenerAtraccionesDelSistema()
{
	Array<pAtraccion> retorno = Array<pAtraccion>(29);

	Array<pCiudad> ciudades = ObtenerCiudadesDelSistema();

	retorno[0] = new AtraccionMock("P12", "Palacio Legislativo", 10, 17, ciudades[0], 10, NULL);
	retorno[1] = new AtraccionMock("P34", "Palacio Salvo", 12, 20, ciudades[0], 15, NULL);
	retorno[2] = new AtraccionMock("T11", "Torre de las Comunicaciones", 13, 18, ciudades[0], 5, NULL);
	retorno[3] = new AtraccionMock("P56", "Parador de Playa los dedos", 9, 19, ciudades[1], 18, NULL);
	retorno[4] = new AtraccionMock("P78", "Parador de Playa El Emir", 0, 17, ciudades[1], 10, NULL);
	retorno[5] = new AtraccionMock("T55", "Torre Eiffel", 8, 23, ciudades[8], 30, NULL);
	retorno[6] = new AtraccionMock("P98", "Paseo por Sena", 10, 20, ciudades[8], 20, NULL);
	retorno[7] = new AtraccionMock("A33", "Arco de Triunfo", 8, 18, ciudades[8], 18, NULL);
	retorno[8] = new AtraccionMock("P22", "Parque Guell", 10, 20, ciudades[11], 10, NULL);
	retorno[9] = new AtraccionMock("C33", "Camp Nou", 8, 20, ciudades[11], 44, NULL);
	retorno[10] = new AtraccionMock("E43", "El Retiro", 6, 23, ciudades[12], 5, NULL);
	retorno[11] = new AtraccionMock("P15", "Museo del Prado", 10, 19, ciudades[12], 17, NULL);
	retorno[12] = new AtraccionMock("T22", "Teleférico", 10, 17, ciudades[3], 30, NULL);
	retorno[13] = new AtraccionMock("C43", "Casa de Ana Frank", 8, 17, ciudades[9], 75, NULL);
	retorno[14] = new AtraccionMock("T01", "Tour en bici", 12, 17, ciudades[9], 20, NULL);
	retorno[15] = new AtraccionMock("P37", "Partenón", 8, 17, ciudades[21], 41, NULL);
	retorno[16] = new AtraccionMock("A41", "Acrópolis", 10, 17, ciudades[21], 26, NULL);
	retorno[17] = new AtraccionMock("C89", "Casa Rosada", 12, 18, ciudades[2], 11, NULL);
	retorno[18] = new AtraccionMock("Z23", "Zoo", 8, 18, ciudades[3], 22, NULL);
	retorno[19] = new AtraccionMock("C18", "Paseo en Cable Car", 6, 22, ciudades[5], 6, NULL);
	retorno[20] = new AtraccionMock("T77", "Willis Tower", 10, 19, ciudades[6], 36, NULL);
	retorno[21] = new AtraccionMock("E52", "Empire State", 10, 19, ciudades[7], 40, NULL);
	retorno[22] = new AtraccionMock("T57", "Tower Bridge", 7, 20, ciudades[10], 6, NULL);
	retorno[23] = new AtraccionMock("B57", "Buckingham palace", 9, 18, ciudades[10], 45, NULL);
	retorno[24] = new AtraccionMock("T72", "Paseo por gondolas", 7, 18, ciudades[20], 13, NULL);
	retorno[25] = new AtraccionMock("C69", "Coliseo", 7, 19, ciudades[19], 21, NULL);
	retorno[26] = new AtraccionMock("M65", "Museo oceanografico", 10, 18, ciudades[13], 29, NULL);
	retorno[27] = new AtraccionMock("M17", "Museo del chocolate", 11, 17, ciudades[16], 15, NULL);
	retorno[28] = new AtraccionMock("T75", "The Peak", 8, 22, ciudades[15], 50, NULL);

	return retorno;
}

Cadena CasoDePrueba::GetNombre()const
{
	return "Casos de Prueba";
}

void CasoDePrueba::CorrerPruebaConcreta()
{
	PruebaOKIngresoCiudad();
	PruebaOKIngresoAtraccion();
	PruebaOKCalificarAtraccion();
	PruebaOKAltaConexion();
	PruebaOKConsultaAtraccion();
	PruebaOKTransportes();
	PruebaOKCiudadMejoresAtracciones();
	PruebaOKIngresoExcursionItinerario();
	PruebaOKIngresoExcursionDistancia();
	PruebaOKIngresoExcursionCosto();
	PruebaOKConsultaExcursion();
	PruebaOKListadoCiudades();
	PruebaOKHayCamino();
	PruebaOKAtraccionesAVisitarA();
	PruebaOKAtraccionesAVisitarB();
	PruebaOKMaximosViajantes();
	PruebaOKCiudadesEsenciales();

	PruebaERRORIngresoCiudad();
	PruebaERRORIngresoAtraccion();
	PruebaERRORCalificarAtraccion();
	PruebaERRORAltaConexion();
	PruebaERRORConsultaAtraccion();
	PruebaERRORTransportes();
	PruebaERRORCiudadMejoresAtracciones();
	PruebaERRORIngresoExcursionItinerario();
	PruebaERRORIngresoExcursionDistancia();
	PruebaERRORIngresoExcursionCosto();
	PruebaERRORConsultaExcursion();
	PruebaERRORListadoCiudades();
	PruebaERRORHayCamino();
	PruebaERRORAtraccionesAVisitarA();
	PruebaERRORAtraccionesAVisitarB();
	PruebaERRORMaximosViajantes();
	PruebaERRORCiudadesEsenciales();
}

void CasoDePrueba::Verificar(TipoRetorno obtenido, TipoRetorno esperado, Cadena comentario)
{
	if (!ignorarOK || obtenido != esperado)
		Prueba::Verificar(obtenido, esperado, comentario);
}

template <class T>
void CasoDePrueba::Verificar(const T& obtenido, const T& esperado, Cadena comentario)
{
	Verificar(SonIguales(obtenido, esperado) ? OK : ERROR, OK, comentario.DarFormato(ObtenerTexto(obtenido), ObtenerTexto(esperado)));
}

template <class T>
void CasoDePrueba::VerificarConjuntos(Iterador<T> obtenidos, Iterador<T> esperados, Cadena comentarioEncontrado, Cadena comentarioFalta, Cadena comentarioSobra)
{
	bool verificarCantidad = true;
	nat totalObtenidos = 0;
	foreach (obtenido, obtenidos)
	{
		totalObtenidos++;
		bool esta = false;
		foreach (esperado, esperados)
		{
			if (SonIguales(obtenido, esperado))
			{
				Verificar(OK, OK, comentarioEncontrado.DarFormato(ObtenerTexto(obtenido), ObtenerTexto(esperado)));
				esta = true;
				break;
			}
		}
		if (!esta)
		{
			Verificar(ERROR, OK, comentarioSobra.DarFormato(ObtenerTexto(obtenido)));
			verificarCantidad = false;
		}
	}
	nat totalEsperados = 0;
	foreach (esperado, esperados)
	{
		totalEsperados++;
		bool esta = false;
		foreach (obtenido, obtenidos)
		{
			if (SonIguales(obtenido, esperado))
			{
				esta = true;
				break;
			}
		}
		if (!esta)
		{
			Verificar(ERROR, OK, comentarioFalta.DarFormato(ObtenerTexto(esperado)));
			verificarCantidad = false;
		}
	}
	if (verificarCantidad && totalObtenidos != totalEsperados)
		Verificar(ERROR, OK, "Se verifica la cantidad de elementos de los conjuntos");
}

template <class T>
void CasoDePrueba::VerificarSecuencias(Iterador<T> obtenidos, Iterador<T> esperados, Cadena comentarioEncontrado, Cadena comentarioFalta, Cadena comentarioSobra)
{
	esperados.Reiniciar();

	foreach (obtenido, obtenidos)
	{
		if (esperados.HayElemento())
		{
			T esperado = *esperados;
			esperados++;
			Verificar(obtenido, esperado, comentarioEncontrado);
		}
		else
			Verificar(ERROR, OK, comentarioSobra.DarFormato(ObtenerTexto(obtenido)));
	}

	while (esperados.HayElemento())
	{
		T esperado = *esperados;
		esperados++;
		Verificar(ERROR, OK, comentarioFalta.DarFormato(ObtenerTexto(esperado)));
	}
}

template <class T>
bool CasoDePrueba::SonIguales(Iterador<T> obtenidos, Iterador<T> esperados) const
{
	obtenidos.Reiniciar();
	esperados.Reiniciar();
	while (obtenidos.HayElemento() && esperados.HayElemento())
	{
		if (!SonIguales(*obtenidos, *esperados))
			return false;
		obtenidos++;
		esperados++;
	}

	return esperados.HayElemento() == obtenidos.HayElemento();
}

template <class T>
bool CasoDePrueba::Pertenece(const T& obtenido, Iterador<T> esperados) const
{
	foreach (esperado, esperados)
	{
		if (SonIguales(obtenido, esperado))
			return true;
	}
	return false;
}

void CasoDePrueba::VerificarConsultaAtraccion(Tupla<TipoRetorno, pAtraccion> obtenido, Tupla<TipoRetorno, pAtraccion> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		Verificar(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}

void CasoDePrueba::VerificarTransportes(Tupla<TipoRetorno, Iterador<Tupla<Cadena, Cadena, TipoTransporte, nat>>> obtenido, Tupla<TipoRetorno, Iterador<Tupla<Cadena, Cadena, TipoTransporte, nat>>> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		VerificarSecuencias(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		//VerificarConjuntos(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}

void CasoDePrueba::VerificarCiudadMejoresAtracciones(Tupla<TipoRetorno, pCiudad> obtenido, Tupla<TipoRetorno, pCiudad> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		Verificar(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}

void CasoDePrueba::VerificarConsultaExcursion(Tupla<TipoRetorno, pExcursion> obtenido, Tupla<TipoRetorno, pExcursion> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		Verificar(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}");
		VerificarSecuencias(obtenido.Dato2->ObtenerItinerario(), esperado.Dato2->ObtenerItinerario(), "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}

void CasoDePrueba::VerificarListadoCiudades(Tupla<TipoRetorno, Iterador<pCiudad>> obtenido, Tupla<TipoRetorno, Iterador<pCiudad>> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		VerificarSecuencias(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		//VerificarConjuntos(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}

void CasoDePrueba::VerificarHayCamino(Tupla<TipoRetorno, bool> obtenido, Tupla<TipoRetorno, bool> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		Verificar(obtenido.Dato2 == esperado.Dato2 ? OK : ERROR, OK, "Se verifica el booleano.");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}

void CasoDePrueba::VerificarAtraccionesAVisitarA(Tupla<TipoRetorno, Iterador<pAtraccion>> obtenido, Tupla<TipoRetorno, Iterador<pAtraccion>> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		//VerificarSecuencias(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		VerificarConjuntos(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}

void CasoDePrueba::VerificarAtraccionesAVisitarB(Tupla<TipoRetorno, Iterador<pAtraccion>> obtenido, Tupla<TipoRetorno, Iterador<pAtraccion>> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		//VerificarSecuencias(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		VerificarConjuntos(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}

void CasoDePrueba::VerificarMaximosViajantes(Tupla<TipoRetorno, nat> obtenido, Tupla<TipoRetorno, nat> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		Verificar(obtenido.Dato2 == esperado.Dato2 ? OK : ERROR, OK, Cadena("Se obtuvo {0} y se esperaba {1}").DarFormato(ObtenerTexto(obtenido.Dato2), ObtenerTexto(esperado.Dato2)));
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}

void CasoDePrueba::VerificarCiudadesEsenciales(Tupla<TipoRetorno, Iterador<pCiudad>> obtenido, Tupla<TipoRetorno, Iterador<pCiudad>> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		VerificarConjuntos(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}


void CasoDePrueba::VerificarExcursiones(Tupla<TipoRetorno, pExcursion> obtenido, Tupla<TipoRetorno, pExcursion> esperado, Cadena comentario)
{
	if (obtenido.Dato1 == OK && esperado.Dato1 == OK)
	{
		IniciarSeccion(comentario, esperado.Dato1);
		VerificarSecuencias(obtenido.Dato2->ObtenerItinerario(), esperado.Dato2->ObtenerItinerario(), "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		//VerificarConjuntos(obtenido.Dato2, esperado.Dato2, "Se obtuvo {0} y se esperaba {1}", "Se esperaba {0}", "No se esperaba {0}");
		CerrarSeccion();
	}
	else
		Verificar(obtenido.Dato1, esperado.Dato1, comentario);
}


bool CasoDePrueba::SonIguales(const pCiudad& obtenido, const pCiudad& esperado) const
{
	return obtenido->ObtenerNombre() == esperado->ObtenerNombre();
}

Cadena CasoDePrueba::ObtenerTexto(const pCiudad& c) const
{
	return c->ObtenerNombre();
}

bool CasoDePrueba::SonIguales(const pAtraccion& obtenido, const pAtraccion& esperado) const
{
	return obtenido->ObtenerIdentificador() == esperado->ObtenerIdentificador() && obtenido->ObtenerNombre() == esperado->ObtenerNombre() && obtenido->ObtenerHorarioInicio() == esperado->ObtenerHorarioInicio() && obtenido->ObtenerHorarioFin() == esperado->ObtenerHorarioFin() && SonIguales(obtenido->ObtenerCiudad(), esperado->ObtenerCiudad()) /* cuidado con posibles stack overflows */ && obtenido->ObtenerPrecio() == esperado->ObtenerPrecio() && SonIguales(obtenido->ObtenerCalificaciones(), esperado->ObtenerCalificaciones());
}

Cadena CasoDePrueba::ObtenerTexto(const pAtraccion& a) const
{
	return a->ObtenerNombre();
}

bool CasoDePrueba::SonIguales(const pExcursion& obtenido, const pExcursion& esperado) const
{
	return obtenido->ObtenerNroExcursion() == esperado->ObtenerNroExcursion() && obtenido->ObtenerFecha() == esperado->ObtenerFecha() && obtenido->ObtenerCostoTotal() == esperado->ObtenerCostoTotal();
}

Cadena CasoDePrueba::ObtenerTexto(const pExcursion& e) const
{
	return "Indefinido";
}

bool CasoDePrueba::SonIguales(const Tupla<nat, int, Cadena>& obtenido, const Tupla<nat, int, Cadena>& esperado) const
{
	return obtenido.Dato1 == esperado.Dato1 && obtenido.Dato2 == esperado.Dato2 && obtenido.Dato3 == esperado.Dato3;
}

Cadena CasoDePrueba::ObtenerTexto(const Tupla<nat, int, Cadena>& t) const
{
	return t.Dato3;
}

bool CasoDePrueba::SonIguales(const Tupla<pCiudad, TipoTransporte, nat, nat>& obtenido, const Tupla<pCiudad, TipoTransporte, nat, nat>& esperado) const
{
	return SonIguales(obtenido.Dato1, esperado.Dato1) /* cuidado con posibles stack overflows */ && obtenido.Dato2 == esperado.Dato2 && obtenido.Dato3 == esperado.Dato3 && obtenido.Dato4 == esperado.Dato4;
}

Cadena CasoDePrueba::ObtenerTexto(const Tupla<pCiudad, TipoTransporte, nat, nat>& t) const
{
	return ObtenerTexto(t.Dato1); /* cuidado con posibles stack overflows*/
}

bool CasoDePrueba::SonIguales(const Tupla<Cadena, Cadena, TipoTransporte, nat>& obtenido, const Tupla<Cadena, Cadena, TipoTransporte, nat>& esperado) const
{
	return obtenido.Dato1 == esperado.Dato1 && obtenido.Dato2 == esperado.Dato2 && obtenido.Dato3 == esperado.Dato3 && obtenido.Dato4 == esperado.Dato4;
}

Cadena CasoDePrueba::ObtenerTexto(const Tupla<Cadena, Cadena, TipoTransporte, nat>& t) const
{
	return m_PlantillaTransporte.DarFormato(t.Dato1,t.Dato2,ObtenerTexto(t.Dato3),ObtenerTexto(t.Dato4));
}

Cadena CasoDePrueba::ObtenerTexto(const TipoTransporte& t) const
{
	switch (t)
	{
	case Omnibus:
		return "Omnibus";
	case Avion:
		return "Avion";
	default:
		assert(false);
		return "INDEFINIDO";
	}
}

Cadena CasoDePrueba::ObtenerTexto(nat n) const
{
	switch (n)
	{
	case 0:
		return "0";
	case 1:
		return "1";
	case 2:
		return "2";
	case 3:
		return "3";
	case 4:
		return "4";
	case 5:
		return "5";
	case 6:
		return "6";
	case 7:
		return "7";
	case 8:
		return "8";
	case 9:
		return "9";
	default:
		Cadena ret = "";
		while (n != 0)
		{
			ret = ObtenerTexto(n % 10) + ret;
			n /= 10;
		}
		return ret;
	}
}

void CasoDePrueba::PruebaOKIngresoCiudad()
{
	IniciarSeccion("Ingreso Ciudad");
	Puntero<ISistema> interfaz = InicializarSistema();

	InicializarCiudad(interfaz);
	CerrarSeccion();
}

void CasoDePrueba::PruebaOKIngresoAtraccion()
{
	IniciarSeccion("Ingreso Atraccion");
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	ignorarOK = false;
	InicializarAtraccion(interfaz);
	CerrarSeccion();
}

void CasoDePrueba::PruebaOKCalificarAtraccion()
{
	IniciarSeccion("Calificar Atraccion");
	Puntero<ISistema> interfaz = InicializarSistema();
	Cadena comentario = "Se califica la atraccion {0} con el valor {1}";

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);
	ignorarOK = false;

	Verificar(interfaz->CalificarAtraccion(20120111, "T11", 1, "Mas feo de lo que me imaginaba"), OK, comentario.DarFormato("T11", "1"));
	Verificar(interfaz->CalificarAtraccion(20130510, "P98", 3, "Lindo! Aunque mucha cola para entrar"), OK, comentario.DarFormato("P98", "3"));
	Verificar(interfaz->CalificarAtraccion(20120301, "P12", 5, "Muy recomendable!! Me encanto"), OK, comentario.DarFormato("P12", "5"));
	Verificar(interfaz->CalificarAtraccion(20110825, "A41", 5, "Un sueño!"), OK, comentario.DarFormato("A41", "5"));
	Verificar(interfaz->CalificarAtraccion(20100108, "M17", 3, "Entretenido"), OK, comentario.DarFormato("P12", "3"));
	Verificar(interfaz->CalificarAtraccion(20100108, "C43", -5, "No lo recomiendo!"), OK, comentario.DarFormato("C43", "-5"));
	
	//Otra calificacion diferente para una misma atracción
	Verificar(interfaz->CalificarAtraccion(20100711, "P12", -3, "Muy caro para lo que es"), OK, comentario.DarFormato("P12", "-3"));

	//Diferente calificacion para misma fecha
	Verificar(interfaz->CalificarAtraccion(20100108, "M17", 2, "Entretenido"), OK, comentario.DarFormato("M17", "2"));

	CerrarSeccion();
}

void CasoDePrueba::PruebaOKAltaConexion()
{
	IniciarSeccion("Alta Conexion");
	Puntero<ISistema> interfaz = InicializarSistema();	
	Cadena comentario = "Se da de alta la conexión {0}-{1}";
	
	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);
	ignorarOK = false;

	InicializarConexion(interfaz);
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaOKConsultaAtraccion()
{
	IniciarSeccion("Consulta Atraccion");
	Puntero<ISistema> interfaz = InicializarSistema();
	Cadena comentario = "Se consulta la atracción {0}";

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);
	ignorarOK = false;

	Tupla<TipoRetorno, pAtraccion> esperado;
	Tupla<TipoRetorno, pAtraccion> obtenido;
	
	//Prueba 1
	obtenido = interfaz->ConsultaAtraccion("P12");
	esperado = Tupla<TipoRetorno, pAtraccion>(OK, ObtenerAtraccionesDelSistema()[0]);

	VerificarConsultaAtraccion(obtenido, esperado, comentario.DarFormato("P12"));

	//Prueba 2
	obtenido = interfaz->ConsultaAtraccion("T01");
	esperado = Tupla<TipoRetorno, pAtraccion>(OK, ObtenerAtraccionesDelSistema()[14]);

	VerificarConsultaAtraccion(obtenido, esperado, comentario.DarFormato("T01"));

	//Prueba 3 - Calificar atraccion y verificar que se muestra correctamente

	interfaz->CalificarAtraccion(20120301, "P12", 5, "Muy recomendable!! Me encanto");
	interfaz->CalificarAtraccion(20101107, "P12", -3, "Muy caro para lo que es");
	interfaz->CalificarAtraccion(20130101, "P12", 4, "Muy lindo...");


	Array<Tupla<nat, int, Cadena>> calificaciones(3);
	calificaciones[0] = Tupla<nat, int, Cadena>(20101107, -3, "Muy caro para lo que es");
	calificaciones[1] = Tupla<nat, int, Cadena>(20120301, 5, "Muy recomendable!! Me encanto");
	calificaciones[2] = Tupla<nat, int, Cadena>(20130101, 4, "Muy lindo...");
	pAtraccion atraccionEsperada = new AtraccionMock("P12", "Palacio Legislativo", 10, 17, ObtenerCiudadesDelSistema()[0], 10, calificaciones.ObtenerIterador());

	obtenido = interfaz->ConsultaAtraccion("P12");
	esperado = Tupla<TipoRetorno, pAtraccion>(OK, atraccionEsperada);
	VerificarConsultaAtraccion(obtenido, esperado, comentario.DarFormato("P12"));

	CerrarSeccion();
}

void CasoDePrueba::PruebaOKTransportes()
{
	IniciarSeccion("Transportes");
	Puntero<ISistema> interfaz = InicializarSistema();
	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);
	InicializarConexion(interfaz);
	
	ignorarOK = false;

	Tupla<TipoRetorno, Iterador<Tupla<Cadena, Cadena, TipoTransporte, nat>>> esperado;
	Tupla<TipoRetorno, Iterador<Tupla<Cadena, Cadena, TipoTransporte, nat>>> obtenido;

	obtenido = interfaz->Transportes();

	Array<Tupla<Cadena, Cadena, TipoTransporte, nat>> listado(37);
	listado[0] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Amsterdam", "Londres", Avion, 4);
	listado[1] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Amsterdam", "Londres", Omnibus, 1);
	listado[2] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Amsterdam", "Paris", Avion, 3);
	listado[3] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Amsterdam", "Paris", Omnibus, 2);
	listado[4] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Barcelona", "Valencia", Avion, 3); 
	listado[5] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Barcelona", "Valencia", Omnibus, 1);
	listado[6] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Brujas", "Bruselas", Avion, 2);
	listado[7] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Brujas", "Bruselas", Omnibus, 1);
	listado[8] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Buenos Aires", "Montevideo", Avion, 3);
	listado[9] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Buenos Aires", "Montevideo", Omnibus, 3);
	listado[10] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Buenos Aires", "Rio de Janeiro", Avion, 2);
	listado[11] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Buenos Aires", "Rio de Janeiro", Omnibus, 1);
	listado[12] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Buenos Aires", "San Pablo", Avion, 4);
	listado[13] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Buenos Aires", "San Pablo", Omnibus, 1);
	listado[14] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Chicago", "New York", Avion, 4);
	listado[15] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Chicago", "New York", Omnibus, 1);
	listado[16] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Londres", "Shangai", Avion, 1);
	listado[17] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Miami", "Chicago", Avion, 4);
	listado[18] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Miami", "Chicago", Omnibus, 1);
	listado[19] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Montevideo", "Buenos Aires", Avion, 6);
	listado[20] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Montevideo", "Buenos Aires", Omnibus, 2);
	listado[21] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Montevideo", "Punta del Este", Avion, 1);
	listado[22] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Montevideo", "Punta del Este", Omnibus, 8);
	listado[23] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Montevideo", "Rio de Janeiro", Avion, 4);
	listado[24] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Montevideo", "Rio de Janeiro", Omnibus, 2);
	listado[25] = Tupla<Cadena, Cadena, TipoTransporte, nat>("New York", "San Francisco", Avion, 2);
	listado[26] = Tupla<Cadena, Cadena, TipoTransporte, nat>("New York", "San Francisco", Omnibus, 1);
	listado[27] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Punta del Este", "Buenos Aires", Avion, 7);
	listado[28] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Punta del Este", "Buenos Aires", Omnibus, 3);
	listado[29] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Rio de Janeiro", "Miami", Avion, 7);
	listado[30] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Rio de Janeiro", "Miami", Omnibus, 1);
	listado[31] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Rio de Janeiro", "San Pablo", Avion, 7);
	listado[32] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Rio de Janeiro", "San Pablo", Omnibus, 4);
	listado[33] = Tupla<Cadena, Cadena, TipoTransporte, nat>("Roma", "Venecia", Avion, 3);
	listado[34] = Tupla<Cadena, Cadena, TipoTransporte, nat>("San Francisco", "Chicago", Avion, 3);
	listado[35] = Tupla<Cadena, Cadena, TipoTransporte, nat>("San Francisco", "Chicago", Omnibus, 1);
	listado[36] = Tupla<Cadena, Cadena, TipoTransporte, nat>("San Francisco", "New York", Avion, 3);

	esperado = Tupla<TipoRetorno, Iterador<Tupla<Cadena, Cadena, TipoTransporte, nat>>>(OK, listado.ObtenerIterador());
	VerificarTransportes(obtenido, esperado, "Se listan los transportes de cada ciudad");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaOKCiudadMejoresAtracciones()
{
	Tupla<TipoRetorno, pCiudad> esperado;
	Tupla<TipoRetorno, pCiudad> obtenido;
	Array<pCiudad> ciudades = ObtenerCiudadesDelSistema();

	IniciarSeccion("Ciudad Mejores Atracciones");
	Puntero<ISistema> interfaz = InicializarSistema();
	
	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);

	Cadena comentarioCalificar = "Se califica la atraccion {0} con el valor {1}";

	ignorarOK = true;
	Verificar(interfaz->CalificarAtraccion(20120111, "T11", 3, "Mas feo de lo que me imaginaba"), OK, comentarioCalificar.DarFormato("T11", "1"));
	Verificar(interfaz->CalificarAtraccion(20130510, "P98", 3, "Lindo! Aunque mucha cola para entrar"), OK, comentarioCalificar.DarFormato("P98", "3"));
	Verificar(interfaz->CalificarAtraccion(20120301, "P12", 5, "Muy recomendable!! Me encanto"), OK, comentarioCalificar.DarFormato("P12", "5"));
	Verificar(interfaz->CalificarAtraccion(20100108, "M17", 3, "Entretenido"), OK, comentarioCalificar.DarFormato("P12", "3"));
	Verificar(interfaz->CalificarAtraccion(20100108, "C43", -5, "No lo recomiendo!"), OK, comentarioCalificar.DarFormato("C43", "-5"));

	ignorarOK = false;

	//Prueba Basica
	esperado = Tupla<TipoRetorno,pCiudad>(OK,ciudades[0]);
	obtenido = interfaz->CiudadMejoresAtracciones();
	VerificarCiudadMejoresAtracciones(obtenido,esperado, "Ciudad Mejores Atracciones -> Montevideo");

	//Prueba ciudades con misma calificacion, me quedo con la que su nombre es menor
	ignorarOK = true;	
	Verificar(interfaz->CalificarAtraccion(20110825, "A41", 4, "Un sueño!"), OK, comentarioCalificar.DarFormato("A41", "5"));
	Verificar(interfaz->CalificarAtraccion(20110825, "T77", 4, "Otro sueño!"), OK, comentarioCalificar.DarFormato("T77", "5"));
	ignorarOK = false;
	esperado = Tupla<TipoRetorno,pCiudad>(OK,ciudades[21]);
	obtenido = interfaz->CiudadMejoresAtracciones();
	VerificarCiudadMejoresAtracciones(obtenido,esperado, "Ciudad Mejores Atracciones -> Atenas");

	//Diferente calificacion para misma fecha
	Verificar(interfaz->CalificarAtraccion(20110825, "A41", 2, "Entretenido"), OK, comentarioCalificar.DarFormato("A41", "2"));
	Verificar(interfaz->CalificarAtraccion(20120301, "P12", 2, "Un poco aburrido"), OK, comentarioCalificar.DarFormato("P12", "1"));
	ignorarOK = false;
	esperado = Tupla<TipoRetorno,pCiudad>(OK,ciudades[6]);
	obtenido = interfaz->CiudadMejoresAtracciones();
	VerificarCiudadMejoresAtracciones(obtenido,esperado, "Ciudad Mejores Atracciones -> Amsterdam");

	ignorarOK = true;
	//Otra calificacion diferente para una misma ciudad
	Verificar(interfaz->CalificarAtraccion(20100712, "T77", -2, "Muy caro para lo que es"), OK, comentarioCalificar.DarFormato("T77", "-2"));
	Verificar(interfaz->CalificarAtraccion(20120718, "P12", 5, "Buenisimo"), OK, comentarioCalificar.DarFormato("P12", "5"));
	Verificar(interfaz->CalificarAtraccion(20120721, "P12", 5, "Especatacular"), OK, comentarioCalificar.DarFormato("P12", "5"));
	
	ignorarOK = false;	
	esperado = Tupla<TipoRetorno,pCiudad>(OK,ciudades[0]);
	obtenido = interfaz->CiudadMejoresAtracciones();
	VerificarCiudadMejoresAtracciones(obtenido,esperado, "Ciudad Mejores Atracciones -> Montevideo");

	CerrarSeccion();
}

void CasoDePrueba::PruebaOKIngresoExcursionItinerario()
{
	IniciarSeccion("Ingreso Excursion Itinerario");
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;
	Array<Cadena> listado(4);
	listado[0] = Cadena("Montevideo");
	listado[1] = Cadena("Punta del Este");
	listado[2] = Cadena("Rio de Janeiro");
	listado[3] = Cadena("New York");

	Verificar(interfaz->IngresoExcursionItinerario(1,20141212, listado.ObtenerIterador()), OK, "Se ingresa la excursión 1: Montevideo, Punta del Este, Rio de Janeiro, New York.");
	
	Array<Cadena> listado2(4);
	listado2[0] = Cadena("Buenos Aires");
	listado2[1] = Cadena("Montevideo");
	listado2[2] = Cadena("Miami");
	listado2[3] = Cadena("New York");

	Verificar(interfaz->IngresoExcursionItinerario(2,20140910, listado2.ObtenerIterador()), OK, "Se ingresa la excursión 2: Buenos Aires, Montevideo, Miami, New York.");


	CerrarSeccion();
}

void CasoDePrueba::PruebaOKIngresoExcursionDistancia()
{
	IniciarSeccion("Ingreso Excursion Distancia");
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;


	Array<Cadena> listado(1);
	listado[0] = Cadena("Punta del Este");
	Verificar(interfaz->IngresoExcursionDistancia(1,20141212,150,"Montevideo", "Chicago", listado.ObtenerIterador()), OK, "Se ingresa la excursión 1 - Origen: Montevideo, Destino: Chicago");
	
	listado[0] = Cadena("Montevideo");
	Verificar(interfaz->IngresoExcursionDistancia(2,20140910,100,"Punta del Este", "New York", listado.ObtenerIterador()), OK, "Se ingresa la excursión 2 - Origen: Punta del Este, Destino: New York");

	CerrarSeccion();
}

void CasoDePrueba::PruebaOKIngresoExcursionCosto()
{
	IniciarSeccion("Ingreso Excursion Costo");
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;
	
	Verificar(interfaz->IngresoExcursionCosto(1,20141212,"Montevideo", "Chicago"), OK, "Se ingresa la excursión 1 - Origen: Montevideo, Destino: Chicago");
	
	Verificar(interfaz->IngresoExcursionCosto(2,20140910,"Punta del Este", "San Francisco"), OK, "Se ingresa la excursión 2 - Origen: Punta del Este, Destino: San Francisco");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaOKConsultaExcursion()
{
	IniciarSeccion("Consulta Excursion");
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;
	
	//INGRESADA POR ITINERARIO
	Array<Cadena> listado(4);
	listado[0] = Cadena("Montevideo");
	listado[1] = Cadena("Punta del Este");
	listado[2] = Cadena("Rio de Janeiro");
	listado[3] = Cadena("New York");

	Verificar(interfaz->IngresoExcursionItinerario(1,20141212, listado.ObtenerIterador()), OK, "Se ingresa la excursión 1: Montevideo, Punta del Este, Rio de Janeiro, New York.");

	Array<Tupla<pCiudad, TipoTransporte, nat, nat>> esperado1(7);
	esperado1[0] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Montevideo"), Omnibus, 0, 0);
	esperado1[1] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Punta del Este"), Avion, 1, 12000);
	esperado1[2] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Buenos Aires"), Avion, 5, 54300);
	esperado1[3] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Rio de Janeiro"), Avion, 20, 204300);
	esperado1[4] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Miami"), Avion, 75, 754300);
	esperado1[5] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Chicago"), Avion, 84, 850500);
	esperado1[6] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("New York"), Avion, 91, 922500);

	pExcursion pEEsperada = new ExcursionMock(1, 20141212, 944500, esperado1.ObtenerIterador());

	VerificarExcursiones(interfaz->ConsultaExcursion(1), Tupla<TipoRetorno, pExcursion>(OK, pEEsperada),"Consultar Excursion Ingresada por Itinerario -> Excursion 1");

	
	//INGRESADA POR DISTANCIA
	Array<Cadena> listado3(1);
	listado3[0] = Cadena("San Pablo");
	Verificar(interfaz->IngresoExcursionDistancia(2,20141212,150,"Punta del Este", "New York", listado3.ObtenerIterador()), OK, "Se ingresa la excursión 2 - Origen: Punta del Este, Destino: New York");
	
	Array<Tupla<pCiudad, TipoTransporte, nat, nat>> esperado2(7);
	esperado2[0] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Punta del Este"), Omnibus, 0, 0);
	esperado2[1] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Buenos Aires"), Avion, 4, 42300);
	esperado2[2] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Montevideo"), Avion, 7, 74600);
	esperado2[3] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Rio de Janeiro"), Avion, 16, 166100);
	esperado2[4] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Miami"), Avion, 71, 716100);
	esperado2[5] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Chicago"), Avion, 80, 812300);
	esperado2[6] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("New York"), Avion, 87, 884300);

	pExcursion pEEsperada2 = new ExcursionMock(2, 20141212, 884300, esperado2.ObtenerIterador());

	VerificarExcursiones(interfaz->ConsultaExcursion(2), Tupla<TipoRetorno, pExcursion>(OK, pEEsperada2),"Consultar Excursion Ingresada por Distancia -> Excursion 2");

	Array<Cadena> listado4(1);
	listado4[0] = Cadena("Montevideo");
	Verificar(interfaz->IngresoExcursionDistancia(3,20140910,150,"Punta del Este", "New York", listado4.ObtenerIterador()), OK, "Se ingresa la excursión 3 - Origen: Punta del Este, Destino: New York");

	Array<Tupla<pCiudad, TipoTransporte, nat, nat>> esperado3(6);
	esperado3[0] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Punta del Este"), Omnibus, 0, 0);
	esperado3[1] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Buenos Aires"), Avion, 4, 42300);
	esperado3[2] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Rio de Janeiro"), Avion, 19, 192300);
	esperado3[3] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Miami"), Avion, 74, 742300);
	esperado3[4] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Chicago"), Avion, 83, 838500);
	esperado3[5] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("New York"), Avion, 90, 910500);

	pExcursion pEEsperada3 = new ExcursionMock(3, 20140910, 910500, esperado3.ObtenerIterador());

	VerificarExcursiones(interfaz->ConsultaExcursion(3), Tupla<TipoRetorno, pExcursion>(OK, pEEsperada3),"Consultar Excursion Ingresada por Distancia -> Excursion 3");

	//INGRESADA POR COSTO
	Verificar(interfaz->IngresoExcursionCosto(4,20141212,"Buenos Aires", "New York"), OK, "Se ingresa la excursión 4 por Costo.");

	Array<Tupla<pCiudad, TipoTransporte, nat, nat>> esperado4(6);
	esperado4[0] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Buenos Aires"), Omnibus, 0, 0);
	esperado4[1] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Montevideo"), Omnibus, 6, 3230);
	esperado4[2] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Rio de Janeiro"), Omnibus, 24, 12380);
	esperado4[3] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Miami"), Omnibus, 138, 69580);
	esperado4[4] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("Chicago"), Omnibus, 157, 79200);
	esperado4[5] = Tupla<pCiudad, TipoTransporte, nat, nat>(new CiudadMock("New York"), Omnibus, 171, 86400);

	pExcursion pEEsperada4 = new ExcursionMock(4, 20141212, 86400, esperado4.ObtenerIterador());

	VerificarExcursiones(interfaz->ConsultaExcursion(4), Tupla<TipoRetorno, pExcursion>(OK, pEEsperada4),"Consultar Excursion Ingresada por Costo -> Excursion 4");

	CerrarSeccion();
}

void CasoDePrueba::PruebaOKListadoCiudades()
{
	IniciarSeccion("Listado Ciudades");
	Puntero<ISistema> interfaz = InicializarSistema();
	
	ignorarOK = true;
	Verificar(interfaz->IngresoCiudad("Chicago"), OK, "");
	Verificar(interfaz->IngresoCiudad("Nebraska"), OK, "");
	Verificar(interfaz->IngresoCiudad("Amsterdam"), OK, "");
	Verificar(interfaz->IngresoCiudad("New York"), OK, "");
	Verificar(interfaz->IngresoCiudad("Buenos Aires"), OK, "");
	Verificar(interfaz->IngresoCiudad("San Antonio"), OK, "");
	Verificar(interfaz->IngresoCiudad("Cordoba"), OK, "");
	Verificar(interfaz->IngresoCiudad("San Francisco"), OK, "");
	ignorarOK = false;

	Array<pCiudad> ciudades = Array<pCiudad>(8);
	ciudades[0] = new CiudadMock("Amsterdam");
	ciudades[1] = new CiudadMock("Buenos Aires");
	ciudades[2] = new CiudadMock("Chicago");
	ciudades[3] = new CiudadMock("Cordoba");
	ciudades[4] = new CiudadMock("Nebraska");
	ciudades[5] = new CiudadMock("New York");
	ciudades[6] = new CiudadMock("San Antonio");
	ciudades[7] = new CiudadMock("San Francisco");

	Tupla<TipoRetorno, Iterador<pCiudad>> esperado;
	Tupla<TipoRetorno, Iterador<pCiudad>> obtenido;

	obtenido = interfaz->ListadoCiudades();
	esperado = Tupla<TipoRetorno, Iterador<pCiudad>>(OK, ciudades.ObtenerIterador());

	VerificarListadoCiudades(obtenido, esperado, "Se listan las ciudades en orden alfabético.");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaOKHayCamino()
{
	IniciarSeccion("Hay Camino");
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;

	Cadena comentario2 = "Se consulta si hay camino entre {0} y {1}";
	Tupla<TipoRetorno, bool> esperado;
	Tupla<TipoRetorno, bool> obtenido;	

	//Prueba 1 (existe camino directo)
	obtenido = interfaz->HayCamino("Londres", "Shangai");
	esperado = Tupla<TipoRetorno, bool>(OK, true);
	VerificarHayCamino(obtenido, esperado, comentario2.DarFormato("Londres","Shangai"));

	//Prueba 2 (existe camino indirecto)
	obtenido = interfaz->HayCamino("Montevideo", "San Pablo");
	esperado = Tupla<TipoRetorno, bool>(OK, true);
	VerificarHayCamino(obtenido, esperado, comentario2.DarFormato("Montevideo","San Pablo"));
	
	//Prueba 3 (no existe camino)
	obtenido = interfaz->HayCamino("Montevideo", "Londres");
	esperado = Tupla<TipoRetorno, bool>(OK, false);
	VerificarHayCamino(obtenido, esperado, comentario2.DarFormato("Montevideo","Londres"));

	//Prueba 4 (no existe camino)
	obtenido = interfaz->HayCamino("San Pablo", "Rio de Janeiro");
	esperado = Tupla<TipoRetorno, bool>(OK, false);
	VerificarHayCamino(obtenido, esperado, comentario2.DarFormato("San Pablo","Rio de Janeiro"));

	CerrarSeccion();
}	

void CasoDePrueba::PruebaOKAtraccionesAVisitarA()
{
	IniciarSeccion("Atracciones AVisitar A");
	Puntero<ISistema> interfaz = InicializarSistema();

	Tupla<TipoRetorno, Iterador<pAtraccion>> obtenidos;
	
	InicializarAtraccionesAVisitar(interfaz);

	obtenidos = interfaz->AtraccionesAVisitarA(1, 115);

	Array<pCiudad> ciudades = Array<pCiudad>(4);
	ciudades[0] = new CiudadMock("Montevideo");
	ciudades[1] = new CiudadMock("Punta del Este");
	ciudades[2] = new CiudadMock("Rio de Janeiro");
	ciudades[3] = new CiudadMock("New York");

	Array<pAtraccion> esperadas = Array<pAtraccion>(7);
	Array<Tupla<nat, int, Cadena>> calificaciones1 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones2 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones3 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones4 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones5 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones6 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones7 = Array<Tupla<nat, int, Cadena>>(2);
	calificaciones1[0] = Tupla<nat, int, Cadena>(20110825, 5, "Un sueño!");
	calificaciones1[1] = Tupla<nat, int, Cadena>(20120301, 5, "Muy recomendable!! Me encanto");
	esperadas[0] = new AtraccionMock("P34", "Palacio Salvo", 12, 20, ciudades[0], 15, calificaciones1.ObtenerIterador());
	calificaciones2[0] = Tupla<nat, int, Cadena>(20110825, 5, "Muy recomendable");
	calificaciones2[1] = Tupla<nat, int, Cadena>(20120301, 5, "Me encantó. La mejor playa que he ido");
	esperadas[1] = new AtraccionMock("P78", "Parador de Playa El Emir", 0, 17, ciudades[1], 10, calificaciones2.ObtenerIterador());
	calificaciones3[0] = Tupla<nat, int, Cadena>(20100108, 5, "La mejor vista");
	calificaciones3[1] = Tupla<nat, int, Cadena>(20130510, 3, "Lindo! Aunque mucha cola para subir");
	esperadas[2] = new AtraccionMock("P22", "Cerro Pan de Azucar", 10, 20, ciudades[2], 10, calificaciones3.ObtenerIterador());
	calificaciones4[0] = Tupla<nat, int, Cadena>(20120111, 4, "Un lugar con mucha historia");
	calificaciones4[1] = Tupla<nat, int, Cadena>(20130510, 3, "Muy lindo el parque que lo rodea");
	esperadas[3] = new AtraccionMock("E56", "Estadio Centenario", 9, 19, ciudades[0], 18, calificaciones4.ObtenerIterador());
	calificaciones5[0] = Tupla<nat, int, Cadena>(20120111, 1, "Mas feo de lo que me imaginaba");
	calificaciones5[1] = Tupla<nat, int, Cadena>(20130510, 3, "Lindo! Aunque mucha cola para entrar");
	esperadas[4] = new AtraccionMock("P12", "Palacio Legislativo", 10, 17, ciudades[0], 10, calificaciones5.ObtenerIterador());
	calificaciones6[0] = Tupla<nat, int, Cadena>(20130509, 1, "Me lo imaginé más lindo");
	calificaciones6[1] = Tupla<nat, int, Cadena>(20130510, 3, "Muy linda la subida en tren");
	esperadas[5] = new AtraccionMock("C33", "Corcovado", 8, 20, ciudades[2], 44, calificaciones6.ObtenerIterador());
	calificaciones7[0] = Tupla<nat, int, Cadena>(20100108, 3, "Entretenido");
	calificaciones7[1] = Tupla<nat, int, Cadena>(20100109, -2, "No lo recomiendo!");
	esperadas[6] = new AtraccionMock("T11", "Torre de las Comunicaciones", 13, 18, ciudades[0], 5, calificaciones7.ObtenerIterador());
	
	Tupla<TipoRetorno, Iterador<pAtraccion>> esperado = Tupla<TipoRetorno, Iterador<pAtraccion>>(OK, esperadas.ObtenerIterador());

	VerificarAtraccionesAVisitarA(obtenidos, esperado, "Atracciones en la Excursión 1");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaOKAtraccionesAVisitarB()
{
	IniciarSeccion("Atracciones AVisitar B");
	Puntero<ISistema> interfaz = InicializarSistema();

	Tupla<TipoRetorno, Iterador<pAtraccion>> obtenidos;
	
	InicializarAtraccionesAVisitar(interfaz);

	obtenidos = interfaz->AtraccionesAVisitarB(1, 115);

	Array<pCiudad> ciudades = Array<pCiudad>(4);
	ciudades[0] = new CiudadMock("Montevideo");
	ciudades[1] = new CiudadMock("Punta del Este");
	ciudades[2] = new CiudadMock("Rio de Janeiro");
	ciudades[3] = new CiudadMock("New York");

	Array<pAtraccion> esperadas = Array<pAtraccion>(7);
	Array<Tupla<nat, int, Cadena>> calificaciones1 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones2 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones3 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones4 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones5 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones6 = Array<Tupla<nat, int, Cadena>>(2);
	Array<Tupla<nat, int, Cadena>> calificaciones7 = Array<Tupla<nat, int, Cadena>>(2);
	calificaciones1[0] = Tupla<nat, int, Cadena>(20110825, 5, "Un sueño!");
	calificaciones1[1] = Tupla<nat, int, Cadena>(20120301, 5, "Muy recomendable!! Me encanto");
	esperadas[0] = new AtraccionMock("P34", "Palacio Salvo", 12, 20, ciudades[0], 15, calificaciones1.ObtenerIterador());
	calificaciones2[0] = Tupla<nat, int, Cadena>(20110825, 5, "Muy recomendable");
	calificaciones2[1] = Tupla<nat, int, Cadena>(20120301, 5, "Me encantó. La mejor playa que he ido");
	esperadas[1] = new AtraccionMock("P78", "Parador de Playa El Emir", 0, 17, ciudades[1], 10, calificaciones2.ObtenerIterador());
	calificaciones3[0] = Tupla<nat, int, Cadena>(20100108, 5, "La mejor vista");
	calificaciones3[1] = Tupla<nat, int, Cadena>(20130510, 3, "Lindo! Aunque mucha cola para subir");
	esperadas[2] = new AtraccionMock("P22", "Cerro Pan de Azucar", 10, 20, ciudades[2], 10, calificaciones3.ObtenerIterador());
	calificaciones4[0] = Tupla<nat, int, Cadena>(20120111, 4, "Un lugar con mucha historia");
	calificaciones4[1] = Tupla<nat, int, Cadena>(20130510, 3, "Muy lindo el parque que lo rodea");
	esperadas[3] = new AtraccionMock("E56", "Estadio Centenario", 9, 19, ciudades[0], 18, calificaciones4.ObtenerIterador());
	calificaciones5[0] = Tupla<nat, int, Cadena>(20120111, 1, "Mas feo de lo que me imaginaba");
	calificaciones5[1] = Tupla<nat, int, Cadena>(20130510, 3, "Lindo! Aunque mucha cola para entrar");
	esperadas[4] = new AtraccionMock("P12", "Palacio Legislativo", 10, 17, ciudades[0], 10, calificaciones5.ObtenerIterador());
	calificaciones6[0] = Tupla<nat, int, Cadena>(20130509, 1, "Me lo imaginé más lindo");
	calificaciones6[1] = Tupla<nat, int, Cadena>(20130510, 3, "Muy linda la subida en tren");
	esperadas[5] = new AtraccionMock("C33", "Corcovado", 8, 20, ciudades[2], 44, calificaciones6.ObtenerIterador());
	calificaciones7[0] = Tupla<nat, int, Cadena>(20100108, 3, "Entretenido");
	calificaciones7[1] = Tupla<nat, int, Cadena>(20100109, -2, "No lo recomiendo!");
	esperadas[6] = new AtraccionMock("T11", "Torre de las Comunicaciones", 13, 18, ciudades[0], 5, calificaciones7.ObtenerIterador());
	
	Tupla<TipoRetorno, Iterador<pAtraccion>> esperado = Tupla<TipoRetorno, Iterador<pAtraccion>>(OK, esperadas.ObtenerIterador());

	VerificarAtraccionesAVisitarB(obtenidos, esperado, "Atracciones en la Excursión 1");

	CerrarSeccion();
}

void CasoDePrueba::PruebaOKMaximosViajantes()
{
	IniciarSeccion("Maximos Viajantes");
	Puntero<ISistema> interfaz = InicializarSistema();
	Cadena comentario = "Máximos viajantes de: {0} a {1}";

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;

	Tupla<TipoRetorno, nat> esperado;
	Tupla<TipoRetorno, nat> obtenido;

	//Prueba 1 - Camino directo
	obtenido = interfaz->MaximosViajantes("Montevideo", "Punta del Este");
	esperado = Tupla<TipoRetorno, nat>(OK, 520);
	VerificarMaximosViajantes(obtenido, esperado, comentario.DarFormato("Montevideo", "Punta del Este"));

	//Prueba 2 - Camino Indirecto 1
	obtenido = interfaz->MaximosViajantes("Montevideo", "San Pablo");
	esperado = Tupla<TipoRetorno, nat>(OK, 2160);
	VerificarMaximosViajantes(obtenido, esperado, comentario.DarFormato("Montevideo", "San Pablo"));

	//Prueba 3 - Camino Indirecto 2 
	ignorarOK = true;
	Verificar(interfaz->AltaConexion("Miami", "Chicago", 881, 6, 14), OK, comentario.DarFormato("Miami","Chicago"));
	ignorarOK = false;
	obtenido = interfaz->MaximosViajantes("Punta del Este", "Chicago");
	esperado = Tupla<TipoRetorno, nat>(OK, 1160);
	VerificarMaximosViajantes(obtenido, esperado, comentario.DarFormato("Punta del Este", "Chicago"));

	//Prueba 4 - No hay camino
	obtenido = interfaz->MaximosViajantes("Montevideo", "Shangai");
	esperado = Tupla<TipoRetorno, nat>(OK, 0);
	VerificarMaximosViajantes(obtenido, esperado, comentario.DarFormato("Montevideo", "Shangai"));
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaOKCiudadesEsenciales()
{
	IniciarSeccion("Ciudades Esenciales");
	Puntero<ISistema> interfaz = InicializarSistema();
	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;

	Array<pCiudad> ciudades = ObtenerCiudadesDelSistema();	

	Cadena comentario = "Ciudades esenciales: {0} -> {1} en {2}";
	Tupla<TipoRetorno, Iterador<pCiudad>> esperado;
	Tupla<TipoRetorno, Iterador<pCiudad>> obtenido;
	Array<pCiudad> retorno;

	//Prueba 1 - No hay ciudades esenciales
	retorno = Array<pCiudad>(0);
	obtenido = interfaz->CiudadesEsenciales("Montevideo", "San Pablo", Avion);
	esperado = Tupla<TipoRetorno, Iterador<pCiudad>>(OK, retorno.ObtenerIterador());
	VerificarCiudadesEsenciales(obtenido, esperado, comentario.DarFormato("Montevideo", "San Pablo", "Avion"));

	//Prueba 2 - No hay ciudades esenciales
	retorno = Array<pCiudad>(0);
	obtenido = interfaz->CiudadesEsenciales("Montevideo", "San Pablo", Omnibus);
	esperado = Tupla<TipoRetorno, Iterador<pCiudad>>(OK, retorno.ObtenerIterador());
	VerificarCiudadesEsenciales(obtenido, esperado, comentario.DarFormato("Montevideo", "San Pablo", "Omnibus"));
	
	//Prueba 3 - hay ciudades esenciales basico
	retorno = Array<pCiudad>(3);
	retorno[0] = ciudades[6];
	retorno[1] = ciudades[4];
	retorno[2] = ciudades[3];

	obtenido = interfaz->CiudadesEsenciales("Montevideo", "New York", Omnibus);
	esperado = Tupla<TipoRetorno, Iterador<pCiudad>>(OK, retorno.ObtenerIterador());
	VerificarCiudadesEsenciales(obtenido, esperado, comentario.DarFormato("Montevideo", "New York", "Omnibus"));
	
	ignorarOK = true;
	Verificar(interfaz->AltaConexion("New York", "Brujas", 210, 2, 0), OK, comentario.DarFormato("New York","Bruselas"));
	Verificar(interfaz->AltaConexion("Chicago", "Brujas", 111, 0, 4), OK, comentario.DarFormato("Chicago","Bruselas"));
	ignorarOK = false;

	//Prueba 4 
	retorno = Array<pCiudad>(2);
	retorno[0] = ciudades[16];
	retorno[1] = ciudades[6];

	obtenido = interfaz->CiudadesEsenciales("San Francisco", "Bruselas", Avion);
	esperado = Tupla<TipoRetorno, Iterador<pCiudad>>(OK, retorno.ObtenerIterador());
	VerificarCiudadesEsenciales(obtenido, esperado, comentario.DarFormato("San Francisco", "Bruselas", "Avion"));

	//Prueba 5
	retorno = Array<pCiudad>(3);
	retorno[0] = ciudades[16];
	retorno[1] = ciudades[6];
	retorno[2] = ciudades[7];
	obtenido = interfaz->CiudadesEsenciales("San Francisco", "Bruselas", Omnibus);
	esperado = Tupla<TipoRetorno, Iterador<pCiudad>>(OK, retorno.ObtenerIterador());
	VerificarCiudadesEsenciales(obtenido, esperado, comentario.DarFormato("San Francisco", "Bruselas", "Omnibus"));

	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORIngresoCiudad()
{
	IniciarSeccion("Ingreso Ciudad", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();
	ignorarOK = true;
	InicializarCiudad(interfaz);
	ignorarOK = false;

	Cadena comentario = "Se da de alta la ciudad {0}";
	//Pruebas de ERROR por mismo nombre
	Verificar(interfaz->IngresoCiudad("Montevideo"), ERROR, comentario.DarFormato("Montevideo"));
	Verificar(interfaz->IngresoCiudad("Miami"), ERROR, comentario.DarFormato("Miami"));

	//Pruebas de ERROR por límite de ciudades
	//Se ingresan 8 ciudades más ya que el límite ingresado es 30
	Verificar(interfaz->IngresoCiudad("Mercedes"), OK, comentario.DarFormato("Mercedes"));
	Verificar(interfaz->IngresoCiudad("San Antonio"), OK, comentario.DarFormato("San Antonio"));
	Verificar(interfaz->IngresoCiudad("Moscú"), OK, comentario.DarFormato("Moscú"));
	Verificar(interfaz->IngresoCiudad("Estocolmo"), OK, comentario.DarFormato("Estocolmo"));
	Verificar(interfaz->IngresoCiudad("Las Vegas"), OK, comentario.DarFormato("Las Vegas"));
	Verificar(interfaz->IngresoCiudad("Helsinki"), OK, comentario.DarFormato("Helsinki"));
	Verificar(interfaz->IngresoCiudad("Kiev"), OK, comentario.DarFormato("Kiev"));
	Verificar(interfaz->IngresoCiudad("Córdoba"), OK, comentario.DarFormato("Córdoba"));
	//Ahora que hay 30 se prueba de ingresar una más
	Verificar(interfaz->IngresoCiudad("Tijuana"), ERROR, comentario.DarFormato("Tijuana"));
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORIngresoAtraccion()
{
	IniciarSeccion("Ingreso Atraccion", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);
	ignorarOK = false;
	Cadena comentario1 = "Se da de alta la atracción con id= {0}";
	Cadena comentario2 = "Se da de alta una atraccion con horario de inicio {0} y fin {1}";
	Cadena comentario3 = "Se da de alta una atracción en la ciudad {0}";
	Cadena comentario4 = "Se da de alta una atracción con precio -5";
	//Prueba ERROR por id repetido
	Verificar(interfaz->IngresoAtraccion("T11", "Cabildo", 1000, 1500, "Montevideo", 25),ERROR, comentario1.DarFormato("T11"));

	//Prueba ERROR por horario de inicio mayor o igual al de fin
	Verificar(interfaz->IngresoAtraccion("Z99", "Cabildo", 1500, 1459, "Montevideo", 25),ERROR, comentario2.DarFormato("1500","1459"));
	Verificar(interfaz->IngresoAtraccion("Z99", "Cabildo", 1500, 1500, "Montevideo", 25),ERROR, comentario2.DarFormato("1500","1500"));
	//Prueba ERROR por ciudad que no existe
	Verificar(interfaz->IngresoAtraccion("Z99", "Cabildo", 1500, 1459, "Artigas", 25),ERROR, comentario3.DarFormato("Artigas"));
	
	//ERROR por precio menor a 0 -> precio es nat 

	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORCalificarAtraccion()
{
	IniciarSeccion("Calificar Atraccion", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();
	Cadena comentario = "Se califica atracción {0}";
	Cadena comentario2 = "Se califica una atracción con puntaje {0}";

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);
	ignorarOK = false;
	//Pruebas de ERROR por atraccion que no existe
	Verificar(interfaz->CalificarAtraccion(20130315, "Z68", 5, "Muuuuy buena") , ERROR, comentario.DarFormato("Z68"));
	Verificar(interfaz->CalificarAtraccion(20130315, "V95", 4, "Buena") , ERROR, comentario.DarFormato("V95"));

	//Pruebas de ERROR por calificacion fuera de rango
	Verificar(interfaz->CalificarAtraccion(20130915, "T11", 6, "Muuuuy buena") , ERROR, comentario2.DarFormato("6"));
	Verificar(interfaz->CalificarAtraccion(20130915, "T11", -6, "Muuuuy buena") , ERROR, comentario2.DarFormato("-6"));

	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORAltaConexion()
{
	IniciarSeccion("Alta Conexion", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);
	ignorarOK = false;
	Cadena comentario = "Se da de alta conexión de {0} a {1}";
	Cadena comentario2 = "Se da de alta una conexión con 0 ómnibus y 0 aviones";
	//Prueba de Ciudad Origen que no existe
	Verificar(interfaz->AltaConexion("Artigas", "Montevideo", 500, 4, 1), ERROR, comentario.DarFormato("Artigas", "Montevideo"));
	//Prueba de Ciudad Destino que no existe
	Verificar(interfaz->AltaConexion("Montevideo", "Beijing", 5500, 1, 5), ERROR, comentario.DarFormato("Montevideo", "Beijing"));
	//Prueba de Ciudad Destino y Origen que no existen
	Verificar(interfaz->AltaConexion("Artigas", "Beijing", 5500, 1, 5), ERROR, comentario.DarFormato("Artigas", "Beijing"));

	//Prueba de ERROR por distancia menor o igual a 0
	Verificar(interfaz->AltaConexion("Montevideo", "Punta del Este", 0, 3, 1), ERROR, comentario.DarFormato("Montevideo", "Punta del Este"));
	//no se prueba con menor a 0 ya que es nat
	Verificar(interfaz->AltaConexion("Montevideo", "Punta del Este", 250, 0, 0), ERROR, comentario2);
	//Prueba de ERROR por cantidad de omnibus y aviones iguales a 0
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORConsultaAtraccion()
{
	IniciarSeccion("Consulta Atraccion", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);
	ignorarOK = false;

	Tupla<TipoRetorno, pAtraccion> esperado;
	Tupla<TipoRetorno, pAtraccion> obtenido;

	Cadena comentario = "Se consulta la atracción con id {0}";
	
	obtenido = interfaz->ConsultaAtraccion("Z55");
	esperado = Tupla<TipoRetorno, pAtraccion>(ERROR, NULL);
	VerificarConsultaAtraccion(obtenido, esperado, comentario.DarFormato("Z55"));

	obtenido = interfaz->ConsultaAtraccion("K35");
	esperado = Tupla<TipoRetorno, pAtraccion>(ERROR, NULL);	
	VerificarConsultaAtraccion(obtenido, esperado, comentario.DarFormato("K35"));
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORTransportes()
{
	IniciarSeccion("Transportes", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();

	Tupla<TipoRetorno, Iterador<Tupla<Cadena, Cadena, TipoTransporte, nat>>> esperado;
	Tupla<TipoRetorno, Iterador<Tupla<Cadena, Cadena, TipoTransporte, nat>>> obtenido;

	
	obtenido = interfaz->Transportes();
	esperado = Tupla<TipoRetorno, Iterador<Tupla<Cadena, Cadena, TipoTransporte, nat>>>(ERROR, NULL);
	VerificarTransportes(obtenido, esperado, "Se consultan los transportes sin haber ciudades en el sistema.");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORCiudadMejoresAtracciones()
{
	IniciarSeccion("Ciudad Mejores Atracciones", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();
	ignorarOK = false;
	InicializarCiudad(interfaz);
	InicializarAtraccion(interfaz);

	Tupla<TipoRetorno, pCiudad> esperado = Tupla<TipoRetorno, pCiudad>(ERROR, NULL);
	Tupla<TipoRetorno, pCiudad> obtenido = interfaz->CiudadMejoresAtracciones();

	VerificarCiudadMejoresAtracciones(obtenido, esperado, "ERROR: Ciudades sin calificaciones");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORIngresoExcursionItinerario()
{
	IniciarSeccion("Ingreso Excursion Itinerario", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;
	Array<Cadena> listado(4);
	listado[0] = Cadena("Montevideo");
	listado[1] = Cadena("Punta del Este");
	listado[2] = Cadena("Rio de Janeiro");
	listado[3] = Cadena("New York");

	Verificar(interfaz->IngresoExcursionItinerario(1,20141212, listado.ObtenerIterador()), OK, "Se ingresa la excursión 1: Montevideo, Punta del Este, Rio de Janeiro, New York.");

	//Probamos ingresar con el mismo NroExcursion	
	Array<Cadena> listado2(4);
	listado2[0] = Cadena("Buenos Aires");
	listado2[1] = Cadena("Montevideo");
	listado2[2] = Cadena("Miami");
	listado2[3] = Cadena("New York");

	Verificar(interfaz->IngresoExcursionItinerario(1,20140910, listado2.ObtenerIterador()), ERROR, "Se intenta ingresar otra excursión número 1.");

	//Probamos ingresar con una ciudad que no existe.
	Array<Cadena> listado3(4);
	listado3[0] = Cadena("Buenos Aires");
	listado3[1] = Cadena("Montevideo");
	listado3[2] = Cadena("Lima");
	listado3[3] = Cadena("New York");

	Verificar(interfaz->IngresoExcursionItinerario(2,20140910, listado3.ObtenerIterador()), ERROR, "Se intenta ingresar una excursión que incluye la ciudad de Lima, ésta no existe en el sistema.");

	//Probamos ingresar una excursión que no es posible.
	Array<Cadena> listado4(4);
	listado4[0] = Cadena("Montevideo");
	listado4[1] = Cadena("Rio de Janeiro");
	listado4[2] = Cadena("San Pablo");
	listado4[3] = Cadena("Miami");

	Verificar(interfaz->IngresoExcursionItinerario(2,20140910, listado4.ObtenerIterador()), ERROR, "Se intenta ingresar una excursión que no es posible, no hay forma de ir de San Pablo a Miami.");

	//Probamos ingresar una más del máximo de exursiones del Sistema.
	ignorarOK = true;
	for(nat i = 2; i<=30; i++)
		Verificar(interfaz->IngresoExcursionItinerario(i,20141212, listado.ObtenerIterador()), OK, "Se ingresa otra excursión.");
	ignorarOK = false;
	Verificar(interfaz->IngresoExcursionItinerario(31,20140910, listado.ObtenerIterador()), ERROR, "Se intenta ingresar una excursión más que el máximo permitidas.");
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORIngresoExcursionDistancia()
{
	IniciarSeccion("Ingreso Excursion Distancia", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();
	
	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;
	
	Array<Cadena> listado(1);
	listado[0] = Cadena("Punta del Este");

	Verificar(interfaz->IngresoExcursionDistancia(1,20141212,150,"Montevideo", "Chicago", listado.ObtenerIterador()), OK, "Se ingresa la excursión 1 - Origen: Montevideo, Destino: Chicago");
	
	//Probamos ingresar con el mismo NroExcursion	
	listado[0] = Cadena("Punta del Este");

	Verificar(interfaz->IngresoExcursionDistancia(1,20140911,150,"Montevideo", "Chicago", listado.ObtenerIterador()), ERROR, "Se intenta ingresar otra excursión número 1.");

	//Probamos ingresar con una ciudad que no existe.
	listado[0] = Cadena("Punta del Este");

	Verificar(interfaz->IngresoExcursionDistancia(1,20140911,150,"Lima", "Chicago", listado.ObtenerIterador()), ERROR, "Se intenta ingresar una excursión con origen en la ciudad de Lima, ésta no existe en el sistema.");

	//Probamos ingresar una excursión que no es posible.
	listado[0] = Cadena("Rio de Janeiro");

	Verificar(interfaz->IngresoExcursionDistancia(1,20140911,150,"Montevideo", "Miami", listado.ObtenerIterador()), ERROR, "Se intenta ingresar una excursión que no es posible, no hay forma de ir de Montevideo a Miami sin pasar por Rio de Janeiro.");

	//Probamos ingresar una más del máximo de exursiones del Sistema.
	ignorarOK = true;
	listado[0] = Cadena("Montevideo");
	for(nat i = 2; i<=30; i++)
		Verificar(interfaz->IngresoExcursionDistancia(i,20140911,150,"Rio de Janeiro", "New York", listado.ObtenerIterador()), OK, "Se ingresa otra excursión.");
	ignorarOK = false;
	Verificar(interfaz->IngresoExcursionDistancia(1,20140911,150,"Rio de Janeiro", "New York", listado.ObtenerIterador()), ERROR, "Se intenta ingresar una excursión más que el máximo permitidas.");

	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORIngresoExcursionCosto()
{
	IniciarSeccion("Ingreso Excursion Costo", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;
	
	Array<Cadena> listado(1);
	listado[0] = Cadena("Punta del Este");

	Verificar(interfaz->IngresoExcursionCosto(1, 20141212,"Montevideo", "Chicago"), OK, "Se ingresa la excursión 1 - Origen: Montevideo, Destino: Chicago");
	
	//Probamos ingresar con el mismo NroExcursion	
	listado[0] = Cadena("Punta del Este");

	Verificar(interfaz->IngresoExcursionCosto(1, 20140911,"Montevideo", "Chicago"), ERROR, "Se intenta ingresar otra excursión número 1.");

	//Probamos ingresar con una ciudad que no existe.
	
	Verificar(interfaz->IngresoExcursionCosto(1, 20140911,"Lima", "Chicago"), ERROR, "Se intenta ingresar una excursión con origen en la ciudad de Lima, ésta no existe en el sistema.");

	//Probamos ingresar una excursión que no es posible.
	
	Verificar(interfaz->IngresoExcursionCosto(1, 20140911,"San Pablo", "Miami"), ERROR, "Se intenta ingresar una excursión que no es posible, no hay forma de ir de San Pablo a Miami.");

	//Probamos ingresar una más del máximo de exursiones del Sistema.
	ignorarOK = true;
	for(nat i = 2; i<=30; i++)
		Verificar(interfaz->IngresoExcursionCosto(i, 20140911,"Rio de Janeiro", "New York"), OK, "Se ingresa otra excursión.");
	ignorarOK = false;
	Verificar(interfaz->IngresoExcursionCosto(1, 20140911,"Rio de Janeiro", "New York"), ERROR, "Se intenta ingresar una excursión más que el máximo permitidas.");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORConsultaExcursion()
{
	IniciarSeccion("Consulta Excursion", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();
	
	VerificarExcursiones(interfaz->ConsultaExcursion(1), Tupla<TipoRetorno, pExcursion>(ERROR, NULL),"Se consulta una Excursión que no existe.");

	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORListadoCiudades()
{
	IniciarSeccion("Listado Ciudades", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();

	Tupla<TipoRetorno, Iterador<pCiudad>> esperado;
	Tupla<TipoRetorno, Iterador<pCiudad>> obtenido;

	
	obtenido = interfaz->ListadoCiudades();
	esperado = Tupla<TipoRetorno, Iterador<pCiudad>>(ERROR, NULL);

	VerificarListadoCiudades(obtenido, esperado, "Se pide el listado de ciudades cuando no hay ninguna ingresada al sistema.");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORHayCamino()
{
	IniciarSeccion("Hay Camino", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();
	ignorarOK = true;
	InicializarCiudad(interfaz);
	ignorarOK = false;
	Cadena comentario = "Se consulta si hay camino entre {0} y {1}";
	Tupla<TipoRetorno, bool> esperado;
	Tupla<TipoRetorno, bool> obtenido;

	//Prueba 1
	obtenido = interfaz->HayCamino("Montevideo", "Guadalajara");
	esperado = Tupla<TipoRetorno, bool>(ERROR, false);
	VerificarHayCamino(obtenido, esperado, comentario.DarFormato("Montevideo", "Guadalajara"));
	
	//Prueba 2
	obtenido = interfaz->HayCamino("Bogotá", "Montevideo");
	esperado = Tupla<TipoRetorno, bool>(ERROR, false);
	VerificarHayCamino(obtenido, esperado, comentario.DarFormato("Bogotá", "Montevideo"));

	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORAtraccionesAVisitarA()
{
	IniciarSeccion("Atracciones AVisitar A", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarAtraccionesAVisitar(interfaz);
	ignorarOK = false;

	//Probamos una excursión que no existe
	Verificar(interfaz->AtraccionesAVisitarA(3, 110).ObtenerDato1(),ERROR,"La excursión no existe");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORAtraccionesAVisitarB()
{
	IniciarSeccion("Atracciones AVisitar B", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();

	ignorarOK = true;
	InicializarAtraccionesAVisitar(interfaz);
	ignorarOK = false;

	//Probamos una excursión que no existe
	Verificar(interfaz->AtraccionesAVisitarB(3, 110).ObtenerDato1(),ERROR,"La excursión no existe");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORMaximosViajantes()
{
	IniciarSeccion("Maximos Viajantes", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();
	ignorarOK = true;
	InicializarCiudad(interfaz);
	ignorarOK = false;

	Tupla<TipoRetorno, nat> esperado;
	Tupla<TipoRetorno, nat> obtenido;

	//Prueba 1
	obtenido = interfaz->MaximosViajantes("Montevideo", "NoExisteCiudad");
	esperado = Tupla<TipoRetorno, nat>(ERROR, 0);
	VerificarMaximosViajantes(obtenido, esperado, "No existe ciudad origen");

	//Prueba 2
	obtenido = interfaz->MaximosViajantes("NoExisteCiudad", "Montevideo");
	esperado = Tupla<TipoRetorno, nat>(ERROR, 0);
	VerificarMaximosViajantes(obtenido, esperado, "No existe ciudad destino");
	
	CerrarSeccion();
}

void CasoDePrueba::PruebaERRORCiudadesEsenciales()
{
	IniciarSeccion("Ciudades Esenciales", ERROR);
	Puntero<ISistema> interfaz = InicializarSistema();
	ignorarOK = true;
	InicializarCiudad(interfaz);
	InicializarConexion(interfaz);
	ignorarOK = false;

	Cadena comentario = "ERROR Ciudades esenciales: {0} -> {1} en {2}";
	Tupla<TipoRetorno, Iterador<pCiudad>> esperado;
	Tupla<TipoRetorno, Iterador<pCiudad>> obtenido;
	Array<pCiudad> retorno;

	//Prueba 1
	retorno = Array<pCiudad>(0);
	obtenido = interfaz->CiudadesEsenciales("Montevideo", "No existe ciudad", Avion);
	esperado = Tupla<TipoRetorno, Iterador<pCiudad>>(ERROR, retorno.ObtenerIterador());
	VerificarCiudadesEsenciales(obtenido, esperado, comentario.DarFormato("Montevideo", "No existe ciudad", "Avion"));

	//Prueba 2
	retorno = Array<pCiudad>(0);
	obtenido = interfaz->CiudadesEsenciales("No existe ciudad", "Montevideo", Avion);
	esperado = Tupla<TipoRetorno, Iterador<pCiudad>>(ERROR, retorno.ObtenerIterador());
	VerificarCiudadesEsenciales(obtenido, esperado, comentario.DarFormato( "No existe ciudad","Montevideo", "Avion"));
	
	CerrarSeccion();

}
